<HTML>
<HEAD>
<TITLE>Managing project files with CVS</TITLE>
</HEAD>
<BODY>
<TABLE BORDER="0" CELLSPACING="1" CELLPADDING="3" BORDER="0" WIDTH="100%">
  <TR>
    <SPAN CLASS="Header">Managing project files and directories with command line CVS</SPAN>
<P>
<SPAN CLASS="PlainText"><B>CVS tool documents: Index</B>
<UL>
<DL>
<DT><A HREF="ddCVS.html">About source code version control with CVS</A>
<DT><A HREF="ddCVS_cvsglossary.html">A version control glossary</A>
<DD><A HREF="ddUsingCVS_command-line.html">Using command-line CVS to access project source files</A>
<DD><A HREF="ddCVS_cvscontributing.html">Contributing source code changes with CVS</A>
<DD><B>You are here: Managing project files and directories with CVS
<UL>
	<LI><A HREF="#cvsrelease">Releasing files</A>
	<LI><A HREF="#cvsremove">Removing files</A>
	<LI><A HREF="#cvsrename&move">Renaming and moving files</A>
	<LI><A HREF="#cvsimport">Importing existing source files</A>
	<LI><A HREF="#cvsandrcs">CVS and RCS</A>
	<LI><A HREF="#keywords">Using keywords</A>
	<LI><A HREF="#aboutbranching">Tagging and branching</A></B>
</UL>
<DT><A HREF="/servlets/HelpTOC">Back to main Help index</A>
</DL>
</UL>
<P>

<HR NOSHADE SIZE=1>
<A NAME="cvsrelease"></A><SPAN CLASS="InputHeader">Releasing files and directories</SPAN>
<P>
At certain point in a project's development cycle, managing your project's source repository invariably involves dealing with files and directories that have become deprecated or obsolete. The decision is made to abandon a certain piece of functionality within a module, for example. Or perhaps an change in infrastructure demands getting rid of some files and moving others. This section deals with several methods for dealing with such file management issues in CVS.
<P>
<I>Releasing</I> refers to a way of designating certain directories or modules that will no longer to be used in the project. The command to release is invoked within a working copy and effectively cancels cvs checkouts for the designated directories and their files. Unless these are expressly deleted, the files and directories actually remain intact within the repository, including all file revision history, but are no longer included in when working copies are checked out.
<P>
The command to release a file or directory is:
<BLOCKQUOTE>
<B>cvs rel filename</B> (or <B>/directory_name</B>)
</BLOCKQUOTE>
<P>
<A HREF="http://www.gnu.org/manual/cvs/html_chapter/cvs_20.html#SEC122" TARGET="_new">More about releasing</A>
<P>

<HR NOSHADE SIZE=1>
<A NAME="cvsremove"></A><span class="InputHeader">Removing files</SPAN>
<P>
<I>Removing</I> is another way to get rid of files when you no longer want or need them to be part of the project's source repository. To do this, you must first delete the file from the working copy you have checked out on your local system.
<P>
Then, to remove a file from the shared repository, type: <BR>
<BLOCKQUOTE>
          <B>cvs remove filename</B>
</BLOCKQUOTE>
After you have removed one or more files, you must commit your changes. 
<P>
With &quot;<B>cvs remove</B>&quot (or &quot;<B>cvs rm</B>&quot), the old file is not completely eradicated but rather stored in CVS' so-called "attic" along with its complete revision history.
<P>
<A HREF="http://www.gnu.org/manual/cvs/html_chapter/cvs_12.html#SEC62" TARGET="_new">More about removing files</A><BR>
<A HREF="http://cvsbook.red-bean.com/cvsbook.html#What_Happens_When_You_Remove_A_File" TARGET="_new">What happens when you remove a file</A>
<P>

<HR NOSHADE SIZE=1>
<A NAME="cvsrename&move"></A><SPAN CLASS="InputHeader">Renaming and moving files and directories</SPAN>

<P>If you have imported some existing source code into your repository, you may have files and directories you want to rename or or move.

<P>The best way to rename a file in your working copy involves a series of steps. Use:
<BLOCKQUOTE>
<B>cvs rm old_filename</B>
</BLOCKQUOTE>
to remove the old name, then 
<BLOCKQUOTE>
<B>cvs add new_filename</B> 
</BLOCKQUOTE>
and finally,
<BLOCKQUOTE>
<B>cvs commit new_filename</B>
</BLOCKQUOTE>

<P>
There really is no specific way in CVS to remove or rename directories. However, you can produce that effect by creating a new directory, moving the files you need into it, removing unwanted files from the old directory, and then simply no longer using it. Later, you can "prune" these empty directories the next time you a check out a working copy by using:
<BLOCKQUOTE>
<B>cvs checkout -P</B>
</BLOCKQUOTE>
Another way to prune directories with no more files is to update with:
<BLOCKQUOTE>
<B>cvs update -dP</B>
</BLOCKQUOTE>

<P>
<A HREF="http://www.gnu.org/manual/cvs/html_chapter/cvs_14.html#SEC67" TARGET="_new">More about moving and renaming files</A><BR>
<A HREF="http://www.gnu.org/manual/cvs/html_chapter/cvs_15.html#SEC71" TARGET="_new">More about moving and renaming directories</A>
<P>

<HR NOSHADE SIZE=1>
<A NAME="cvsimport"></A><SPAN CLASS="InputHeader">Importing existing code?</SPAN>
<P>
If you have existing files to add to the project, you can import these into CVS using the following command:
<BLOCKQUOTE>
		<B>cvs import filename</B>
</BLOCKQUOTE>

<P>
Importing allows you to add a lot of files at once, something like a super "cvs add." To import <I>all</I> existing directories and files, in your top level directory type:
<P>
<B>cvs import -m &quot;log message&quot projectname</B>
<P>
This creates the files and directories in the CVS repository for your project on this site. If you want to preserve these files and directories in their original state, you may want to tag or archive this set of original files before you or any other developers begin checking out working copies of project files.
<P>
If your existing files are already under versioning control -- either in another CVS repository or in a versioning different system such as RCS -- there is no automated method for importing existing files that retains file histories. Using the cvs import command, copying files over, or creating them as new files does not retain these histories.
<P>

<HR NOSHADE SIZE=1>
<A NAME="cvsandrcs"></A><SPAN CLASS="InputHeader">CVS and RCS</SPAN>
<P>
If you're already familiar with RCS, both RCS and CVS use a similar format for storing the version control histories of individual files. But you should be aware of at least two critical differences in adapting CVS:
<P>
<UL>
<LI>One of the central principals in RCS is file locking, which prevents other developers from checking out or modifying a file when you have checked it out. The benefit to file locking is that developers never have to deal with conflicting modifications within files. RCS protects files by only allowing them to be modified by one person at a time. Therefore, the drawback to RCS is: you can't commit your changes to a file while another developer has it checked out.
<LI>The central tenant of CVS is to allow developers to check out, modify, and commit files concurrently, truly a benefit to projects with remote, geographically dispersed developers. The tradeoff is that on a CVS version controlled project, you can count on dealing with merge conflicts in files. The only method for resolving such conflicts is by hand-editing the file. Thus, project workflow with CVS ends up being a little different.
</UL>
<P>
<A HREF="http://www.cvshome.org/cyclic/cyclic-pages/rcs.html" TARGET="_new">More about RCS and CVS</A>
<P>

<HR noShade SIZE=1>
<A NAME="keywords"></A><SPAN CLASS="InputHeader">Keyword substitution</SPAN>
<P>
Keyword substitution (a.k.a keyword expansion) is an RCS holdover that may be useful to you as a developer. Keywords essentially let you embed version information permanently in source files. A string containing the full version information associated with a particular keyword is substituted whenever the file is subsequently revised. 
<P>
As an example, including:
<BLOCKQUOTE>
<B>$Author: templedf $</B>
</BLOCKQUOTE>
within the files permanently retains the login name of the user who checked in that revision.
<P>Keyword substitution is a method for tracking file versions once the files are no longer part of a CVS repository. Keyword substitution can also be configured and suppressed.
<P>
<A HREF="http://cvshome.org/docs/manual/cvs_12.html#SEC98" TARGET="_new">More about keywords (including a list of common keywords)</A>
<P>

<HR NOSHADE SIZE=1>
<A NAME="aboutbranching"></A><SPAN CLASS="InputHeader">Tagging and branching </SPAN>
<P>
The CVS repository for your project hosted on this site supports branching and tagging your source files. At certain points in your project, you may want to enable development work in your project to progress in more than one direction simultaneously. Instead of maintaining a singular, linear path of development, CVS branching provides a way to divert or split the source tree for ancillary development activities without impacting progress of the project's primary effort. Examples of reasons to branch include:
<UL>
<LI>to distinguish a clearly defined set of functionality in project source files for QA and testing, or
<LI>when you want to try an experiment such as added features or functionality without affecting the project's progress.
</UL>
<P>
Tagging is included in the discussion about branching because the two operations are used in conjunction. Tagging allows you to "take a snapshot" of the overall project's state at a certain point in time, for example, to preserve a build with some particular characteristic. Because CVS manages individual file revisions, tagging is an important option for benchmarking the overall state of project source code. Files included in a tag will most likely be at different points in their respective revision numbering.
<P>
The critical difference between branching and tagging is the reason they are complimentary operations:
<BLOCKQUOTE>
Branching affects <I>individual files'</I> revision numbering, whereas tagging assigns a common identifying marker <I>across all project files</I> at a fixed point in time.
</BLOCKQUOTE>
So, for example, project files are often tagged at the point where branches are created.
<P>
Ultimately, branches in your project with successful outcomes get incorporated or merged back in to the main development trunk. When that happens -- and it may occur repeatedly on large or long-term projects -- identifying the point where this merge occurs is another reason to create a tag.
<P>
<A NAME="cvstag"></A>To tag project files, type:
<BLOCKQUOTE>
<B>cvs tag unique_tag_name</B>
</BLOCKQUOTE>
<P>
Your tag name can be a release name or date, a product version identifier, or whatever you choose.
<P>
<A NAME="cvsbranch"></A>To create a branch, type:
<BLOCKQUOTE>
<B>cvs tag -b unique_tag_name </B>
</BLOCKQUOTE>
<P>
Branching and tagging are complex topics with many considerations and  options. You can find more comprehensive information and instructions in the following resources:
<P> 
<UL>
<DL>
<DT><LI>cvshome.org: <A HREF="http://www.cvshome.org/docs/manual/cvs_4.html#SEC48" TARGET="_new">"More about branching and tagging"</A><BR>
<DT><LI>The Cederqvist Manual: <A HREF="http://www.gnu.org/manual/cvs/html_chapter/cvs_8.html#SEC50" TARGET="_new">"Branches"</A><BR>
<DT><LI><I>Open Source Development with CVS</I>:<BR>
<DD><A HREF="http://cvsbook.red-bean.com/cvsbook.html#Marking_A_Moment_In_Time__Tags_" TARGET="_new">"Marking A Moment In Time (Tags)"</A>
<DD><A HREF="http://cvsbook.red-bean.com/cvsbook.html#Branches" TARGET="_new">"Branches"</A>
</UL>
</DL>
<P>

<HR NOSHADE SIZE=1>
<A HREF="/servlets/HelpTOC">Back to main Help index</A></P></SPAN>

</SPAN> 
</TR>
</TABLE>
</BODY>
</HTML>